package p500.srm523;

import utils.ExampleRunner;

/**
 * Created by IntelliJ IDEA.
 * User: smalex
 * Date: 1/7/12
 * Time: 12:46 PM
 */
public class AlphabetPath {
  int[][] dir = new int[][]{{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

  public String doesItExist(String[] letterMaze) {
    int[] prev = find(letterMaze, 'A');
    for (int i = 'B'; i <= 'Z'; i++) {
      int[] next = find(letterMaze, i);
      if (next == null) {
        return "NO";
      }
      int x = Math.abs(next[0] - prev[0]);
      int y = Math.abs(next[1] - prev[1]);
      if (!(x == 0 && y == 1 || x == 1 && y == 0)) {
        return "NO";
      }
      prev = next;
    }

    return "YES";
  }

  private int[] find(String[] letterMaze, int c) {
    for (int i = 0; i < letterMaze.length; i++) {
      for (int j = 0; j < letterMaze[i].length(); j++) {
        if ((int) letterMaze[i].charAt(j) == c) {
          return new int[]{i, j};
        }
      }
    }
    return null;
  }

  public static void main(String[] args) {
    ExampleRunner.eq(1, "YES", new AlphabetPath().doesItExist(new String[]{"ABCDEFGHIJKLMNOPQRSTUVWXYZ"}));
    ExampleRunner.eq(2, "YES", new AlphabetPath().doesItExist(new String[]{"ADEHI..Z", "BCFGJK.Y", ".PONML.X", ".QRSTUVW"}));
    ExampleRunner.eq(3, "NO", new AlphabetPath().doesItExist(new String[]{"ACBDEFGHIJKLMNOPQRSTUVWXYZ"}));
    ExampleRunner.eq(4, "NO", new AlphabetPath().doesItExist(new String[]{"ABC.......", "...DEFGHIJ", "TSRQPONMLK", "UVWXYZ...."}));
    ExampleRunner.eq(5, "YES", new AlphabetPath().doesItExist(new String[]{"..............", "..............", "..............", "...DEFGHIJK...", "...C......L...", "...B......M...", "...A......N...", "..........O...", "..ZY..TSRQP...", "...XWVU.......", ".............."}));
    ExampleRunner.eq(6, "YES", new AlphabetPath().doesItExist(new String[]{"ABCDEFGH", "PONMLKJI", "QRSTUVWX", "......ZY"}));
    ExampleRunner.eq(7, "YES", new AlphabetPath().doesItExist(new String[]{"....ZYXW", ".PQRSTUV", ".ONMLKJI", "ABCDEFGH"}));
    ExampleRunner.eq(8, "YES", new AlphabetPath().doesItExist(new String[]{"MLKJIHGFEDCBA", "N............", "O............", "PQRSTUVWXYZ.."}));
    ExampleRunner.eq(9, "YES", new AlphabetPath().doesItExist(new String[]{"NM", "OL", "PK", "QJ", "RI", "SH", "TG", "UF", "VE", "WD", "XC", "YB", "ZA"}));
    ExampleRunner.eq(10, "YES", new AlphabetPath().doesItExist(new String[]{"ABCDEFGH..........................................", ".......I..........................................", ".......J..........................................", "......LK..........................................", "......M...........................................", "......N...........................................", "......O...........................................", "......P...........................................", "......Q...........................................", "......R...........................................", "......S...........................................", "....VUT...........................................", "...XW.............................................", "...YZ.............................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", ".................................................."}));
    ExampleRunner.eq(11, "YES", new AlphabetPath().doesItExist(new String[]{"..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "ABCDEFGHIJKLMNOPQRSTUVWXYZ........................"}));
    ExampleRunner.eq(12, "YES", new AlphabetPath().doesItExist(new String[]{".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", "...............................OPQRS.....", "...............................NMLKT.....", ".................................IJU.....", "................................GH.V.....", "...............................EF..WX....", "...............................D...ZY....", ".............................ABC.........", ".........................................", ".........................................", "........................................."}));
    ExampleRunner.eq(13, "YES", new AlphabetPath().doesItExist(new String[]{"..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", ".................A........................", "............QP...B........................", "............RON..C........................", "...........TSLM.ED........................", "...........U.KJ.F.........................", "...........VW.IHG.........................", "............XYZ...........................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", ".........................................."}));
    ExampleRunner.eq(14, "YES", new AlphabetPath().doesItExist(new String[]{".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".....DCBA..............................", "....FE.................................", "....GH.................................", ".....I.................................", ".....J.................................", ".....K.................................", "....ML.................................", "....NOP................................", ".....RQ................................", ".....S.................................", ".....T.................................", ".....UVWXYZ............................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", "......................................."}));
    ExampleRunner.eq(15, "YES", new AlphabetPath().doesItExist(new String[]{"..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", ".....................UTQP.........................", ".....................VSRONML......................", ".....................W.ABCDKJ.....................", ".....................X....EFI.....................", "....................ZY.....GH.....................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", ".................................................."}));
    ExampleRunner.eq(16, "YES", new AlphabetPath().doesItExist(new String[]{"...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "..............................UV...........", ".............................STW...........", ".............................R.XY..........", ".............................Q..Z..........", "..........................MNOP.............", ".......................IJKL................", ".......................HG..................", "........................FED................", ".........................BC................", ".........................A.................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "..........................................."}));
    ExampleRunner.eq(17, "YES", new AlphabetPath().doesItExist(new String[]{"............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "....................A.......................", "..................DCB.......................", ".................FE..Z......................", ".................GHIJYXW....................", "..................MLKRSV....................", "..................NOPQTU....................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................"}));
    ExampleRunner.eq(18, "YES", new AlphabetPath().doesItExist(new String[]{".........................", "...VUTSRQ................", "...WXYZ.PO...............", ".........N...............", "........LM...............", "........KJ...............", ".........I...............", ".........H...............", ".........GFCBA...........", "..........ED.............", ".........................", ".........................", ".........................", ".........................", ".........................", "........................."}));
    ExampleRunner.eq(19, "YES", new AlphabetPath().doesItExist(new String[]{"..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "...............................GFE........", "......................YZ......IH.D........", "......................X..QPMLKJ.BC........", "......................WVSRON....A.........", ".......................UT.................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", ".........................................."}));
    ExampleRunner.eq(20, "YES", new AlphabetPath().doesItExist(new String[]{".....................................", ".....................................", ".....................................", ".....................................", ".....................................", ".....................................", ".....................................", ".....................................", ".....................................", "................ZY...................", ".................XW..NM..............", "..................V..OL..............", "..................URQPK..............", "..................TSHIJ..............", "....................GF...............", ".....................E...............", ".....................DCBA............", ".....................................", ".....................................", ".....................................", ".....................................", ".....................................", ".....................................", ".....................................", ".....................................", ".....................................", "....................................."}));
    ExampleRunner.eq(21, "YES", new AlphabetPath().doesItExist(new String[]{"......", "......", "......", "......", "...FGH", ".CDEJI", "ABMLK.", "..N...", "QPO...", "RS....", ".TUZ..", "..VY..", "..WX.."}));
    ExampleRunner.eq(22, "YES", new AlphabetPath().doesItExist(new String[]{".................", ".................", ".................", ".................", ".................", ".................", ".................", ".................", ".................", ".................", "....ZY...........", ".....XW..........", "......VUT........", "........S........", "........R........", "........Q........", "........P........", "........ON.......", ".........ML.FE...", "..........KHGDC..", "..........JI..BA."}));
    ExampleRunner.eq(23, "YES", new AlphabetPath().doesItExist(new String[]{".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", "...EDA...", "...FCB...", ".IHG.....", ".JKL.....", "...M.....", "..ON.....", "..P......", "..Q......", "..RST....", "....UVW..", "....ZYX..", ".........", ".........", ".........", ".........", ".........", ".........", ".........", "........."}));
    ExampleRunner.eq(24, "YES", new AlphabetPath().doesItExist(new String[]{".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".....Z...", "..TUVY...", "..S.WX...", "..R......", "..QPONML.", "....HIJK.", "....G....", "....F....", "....E....", "...CD....", "...BA....", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", "........."}));
    ExampleRunner.eq(25, "YES", new AlphabetPath().doesItExist(new String[]{".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", "..CBA....", ".ED......", "GF.......", "HI.QR....", ".JOPS....", ".KN.T..YZ", ".LM.UVWX.", "........."}));
    ExampleRunner.eq(26, "YES", new AlphabetPath().doesItExist(new String[]{"........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", ".........YZ.............", "......A..X..............", "....DCB.VW..............", "....E..TU...............", "....FGRS................", "...JIHQP................", "...KLMNO................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................"}));
    ExampleRunner.eq(27, "YES", new AlphabetPath().doesItExist(new String[]{".............", "....ML.......", "....NKJ......", "...PO.IHGDCB.", "..ZQR...FE.A.", ".XY.S........", ".WVUT........", "............."}));
    ExampleRunner.eq(28, "YES", new AlphabetPath().doesItExist(new String[]{".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".............VUTS....", "............XWPQR....", "...........ZY.ONM....", "................LK...", ".................J...", "...............GHI...", "...............FAB...", "...............EDC...", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", "....................."}));
    ExampleRunner.eq(29, "YES", new AlphabetPath().doesItExist(new String[]{"........", "........", "........", "........", "........", "........", "........", "........", "........", "........", "........", "........", "........", "........", "........", "........", "........", "........", "........", "........", "........", ".....XYZ", "...AVW..", "...BUTSR", "...CLM.Q", "..EDKNOP", "..FIJ...", "..GH....", "........", "........", "........", "........", "........", "........"}));
    ExampleRunner.eq(30, "YES", new AlphabetPath().doesItExist(new String[]{"........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "..........................ON............", "........................TSPM............", ".......................VURQLKJ..........", ".......................WXY...IHG........", ".........................Z.....F........", "..............................DE........", "..............................C.........", "..............................BA........", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................"}));
    ExampleRunner.eq(31, "YES", new AlphabetPath().doesItExist(new String[]{".............................", ".............................", ".............................", "...................YXW.......", "...................Z.V.......", ".....................UT......", "......................SR.....", ".....................OPQ.....", "...................LMN.......", "...................K.........", "..................IJ.........", "..................HG.........", "................ADEF.........", "................BC...........", ".............................", ".............................", ".............................", ".............................", ".............................", ".............................", ".............................", "............................."}));
    ExampleRunner.eq(32, "YES", new AlphabetPath().doesItExist(new String[]{"......CD.......", ".....ABEF......", "......KJG......", "......LIH......", "......MN.......", ".......O.......", ".......PQR.....", ".........S.....", ".........T.....", ".........U.....", ".......XWV.....", "......ZY.......", "...............", "...............", "...............", "...............", "..............."}));
    ExampleRunner.eq(33, "YES", new AlphabetPath().doesItExist(new String[]{".................................", ".......EDC.......................", ".......FAB.......................", ".......GHI.......................", ".......LKJ.......................", ".......M.........................", ".......N.........................", ".......OPQR......................", ".....ZYXWVS......................", ".........UT......................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", "................................."}));
    ExampleRunner.eq(34, "YES", new AlphabetPath().doesItExist(new String[]{"........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........ZYVUTQP....A....", ".........XW.SRO....B....", "..............NMLEDC....", "................KF......", "................JG......", "................IH......", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................", "........................"}));
    ExampleRunner.eq(35, "YES", new AlphabetPath().doesItExist(new String[]{"...........", "...........", "...........", "...........", "...........", "...........", ".........A.", ".......FEB.", "......HGDC.", ".ZWVUTIJK..", ".YX..SRML..", "......QN...", "......PO...", "...........", "...........", "...........", "...........", "...........", "...........", "..........."}));
    ExampleRunner.eq(36, "YES", new AlphabetPath().doesItExist(new String[]{".............CB...............", ".............DA...............", ".............E................", ".............F.........Z......", ".............GLMPQ.UVWXY......", ".............HKNORST..........", ".............IJ..............."}));
    ExampleRunner.eq(37, "YES", new AlphabetPath().doesItExist(new String[]{"............", "............", ".........HI.", "......DEFGJ.", "......CPO.K.", ".....ABQNML.", ".......RST..", "......XWVU..", ".....ZY.....", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............", "............"}));
    ExampleRunner.eq(38, "YES", new AlphabetPath().doesItExist(new String[]{"............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................UTS.............", "...........................WV.RQ............", "...........................X...PO...........", "...........................Y...MN...........", "...........................Z.JKL............", ".............................IH..CB.........", "..............................GFEDA.........", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................"}));
    ExampleRunner.eq(39, "YES", new AlphabetPath().doesItExist(new String[]{".............................", ".............A...............", "...........DCB...............", "...........EF................", "...........HG................", "...........IJ................", "...........LK................", "..........NM.................", "..........OP.................", "...........Q.................", "..........SR.................", "........VUT..................", "........W....................", "........XY...................", ".........Z...................", ".............................", ".............................", ".............................", ".............................", ".............................", "............................."}));
    ExampleRunner.eq(40, "YES", new AlphabetPath().doesItExist(new String[]{"....STUVWX.", "....R...ZY.", "....Q......", "....P......", "....O......", ".IJ.N......", ".HKLM......", ".G.........", ".F.........", ".E.........", "CD.........", "B..........", "A..........", "...........", "...........", "...........", "...........", "...........", "...........", "...........", "...........", "...........", "...........", "...........", "...........", "...........", "...........", "...........", "...........", "..........."}));
    ExampleRunner.eq(41, "YES", new AlphabetPath().doesItExist(new String[]{"................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "..................SRQ....HGF....................", "..................T.PON.JI.E....................", "..................U.YZMLK..DC...................", "..................VWX......AB...................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................", "................................................"}));
    ExampleRunner.eq(42, "YES", new AlphabetPath().doesItExist(new String[]{".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", "........BC...............", "........AD...............", "........FE...............", "........GH...............", ".........I...............", ".........J...............", ".........K...............", "........ML...............", "........N................", "......QPO................", "......RS.................", ".......TUV...............", ".........WX..............", "..........Y..............", "..........Z..............", ".........................", ".........................", ".........................", ".........................", "........................."}));
    ExampleRunner.eq(43, "YES", new AlphabetPath().doesItExist(new String[]{"............................", "............................", "............................", "............................", "............................", "............................", "............AZ..............", "............BYTSR...........", "...........DCXU.Q...........", "...........E.WVOP...........", "...........FGH.N............", ".............I.M............", ".............JKL............", "............................", "............................", "............................", "............................", "............................", "............................", "............................", "............................"}));
    ExampleRunner.eq(44, "YES", new AlphabetPath().doesItExist(new String[]{"..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..........................................CBA.....", "..........................................D.......", "......................................MLKJEF......", ".....................................ONSTIHG......", ".....................................PQRU.........", "........................................V.........", ".......................................XW.........", ".......................................Y..........", ".......................................Z..........", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", ".................................................."}));
    ExampleRunner.eq(45, "YES", new AlphabetPath().doesItExist(new String[]{".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", "................DE...............", "..............YZCFGHIJK..........", "..............X.BAPONML..........", "..............W...Q..............", "..............VUTSR..............", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", ".................................", "................................."}));
    ExampleRunner.eq(46, "YES", new AlphabetPath().doesItExist(new String[]{".................................................", ".................................................", "..............YZ.................................", "..............X..................................", "..............W..................................", "............TUV..................................", "........MNORS....................................", "........LKPQ.....................................", ".........JIHGF...................................", ".............E...................................", ".............DC..................................", "..............B..................................", "..............A..................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", "................................................."}));
    ExampleRunner.eq(47, "YES", new AlphabetPath().doesItExist(new String[]{"..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "....XW............", "...ZYVU...........", "......TSR.........", ".......PQ..HG.....", ".......ONMLIFE....", "..........KJCD....", "...........AB.....", "..................", ".................."}));
    ExampleRunner.eq(48, "YES", new AlphabetPath().doesItExist(new String[]{".................", ".................", ".................", ".................", ".................", ".................", ".................", ".................", ".................", ".................", ".................", ".................", ".................", "..........TS.....", "........YZUR.....", "........XWVQ.....", "...........P.....", "..........NO.....", "..........M......", "..........L......", "..........KJ.....", "...........I.....", "...........HG....", "...........AFE...", "...........BCD..."}));
    ExampleRunner.eq(49, "YES", new AlphabetPath().doesItExist(new String[]{".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", "....................................Z..", "...................................XY..", "..................................VW...", "..................................U....", "..................................TS...", "..................................QR...", "..................................PMLK.", "..................................ONAJ.", "...................................CBI.", "...................................DGH.", "...................................EF..", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", "......................................."}));
    ExampleRunner.eq(50, "YES", new AlphabetPath().doesItExist(new String[]{".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", "............BC...................................", "............ADGH.................................", ".............EFI.................................", "...............J.................................", "...............K.................................", "...............L.................................", "...............M.................................", "...............N...Z.............................", "...............O...YX............................", "...............PQ..VW............................", "................RSTU.............................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", ".................................................", "................................................."}));
    ExampleRunner.eq(51, "YES", new AlphabetPath().doesItExist(new String[]{"...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "....................ZWVU...........", "....................YXST...........", "......................R............", "......................Q............", "......................PONMLIH......", "..........................KJGF.....", "............................DE.....", "............................C......", "............................BA.....", "...................................", "...................................", "..................................."}));
    ExampleRunner.eq(52, "YES", new AlphabetPath().doesItExist(new String[]{".......................................", "............................HI.........", ".........................DEFGJ.........", "........................BC..LK.........", "........................A.ONM..........", ".........................QP............", "....................YXWTSR.............", "....................Z.VU...............", ".......................................", ".......................................", "......................................."}));
    ExampleRunner.eq(53, "YES", new AlphabetPath().doesItExist(new String[]{"..............................................", "..............................................", "..............................................", "......IHG.....................................", "......JKFE....................................", "......ML.DC...................................", "......N..AB...................................", "......OPQRSTUV.Z..............................", ".............WXY..............................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", "..............................................", ".............................................."}));
    ExampleRunner.eq(54, "YES", new AlphabetPath().doesItExist(new String[]{"...............................", "...............................", ".SRQ...........................", ".T.PO..........................", ".U.MN..A.......................", ".V.LKJCB.......................", ".WX..IDE.......................", ".ZY..HGF.......................", "..............................."}));
    ExampleRunner.eq(55, "YES", new AlphabetPath().doesItExist(new String[]{".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".................YZ..........................", ".................X...........................", ".........GH....UVW...........................", ".........FI.QRST.............................", ".........EJOP................................", ".........DKN.................................", "........BCLM.................................", "........A...................................."}));
    ExampleRunner.eq(56, "YES", new AlphabetPath().doesItExist(new String[]{".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", "......GF...............................", "....LKHE...............................", "....MJIDC..............................", "....NO..B..............................", ".....P..A..............................", ".....QR................................", ".....TS................................", ".....UVWXY.............................", ".........Z.............................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", "......................................."}));
    ExampleRunner.eq(57, "YES", new AlphabetPath().doesItExist(new String[]{"..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", ".............YZ...........", "....MNOP.TUVWX............", "...KL..QRS................", "...J......................", "FGHI......................", "ED........................", ".CBA......................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", ".........................."}));
    ExampleRunner.eq(58, "YES", new AlphabetPath().doesItExist(new String[]{"....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", ".............RS..Z..................", ".............QT.XY..................", ".............PUVW...................", ".............ONML...................", "................K...................", "...............IJ...................", "...............HA...................", "..............FGB...................", "..............EDC...................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "...................................."}));
    ExampleRunner.eq(59, "YES", new AlphabetPath().doesItExist(new String[]{"...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", ".........................YXWVUTS...........", ".........................Z.....RQP.........", "................................NO.........", "................................MJIHG......", "................................LK..FED....", "....................................ABC....", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "..........................................."}));
    ExampleRunner.eq(60, "YES", new AlphabetPath().doesItExist(new String[]{"......................AB..................", "......................DC..................", ".....................FE...................", "....................HG..NOPQ..............", "....................IJKLM..R..............", "...........................STUXY..........", ".............................VWZ..........", "..........................................", "..........................................", ".........................................."}));
    ExampleRunner.eq(61, "YES", new AlphabetPath().doesItExist(new String[]{".................", ".................", ".................", ".................", ".................", ".................", ".................", ".................", ".................", ".................", ".................", ".................", "...............DE", "........RQP...BCF", "........S.O...AHG", "......VUT.NMLKJI.", "......WXY........", "........Z........", ".................", ".................", "................."}));
    ExampleRunner.eq(62, "YES", new AlphabetPath().doesItExist(new String[]{"CD.......TUVW", "BE.....QRSZYX", "AF....OP.....", ".G.KLMN......", ".HIJ........."}));
    ExampleRunner.eq(63, "YES", new AlphabetPath().doesItExist(new String[]{"......DC", "......EB", "......FA", "......G.", ".....IH.", ".....J..", "XWV..K..", "Y.U..L..", "Z.TONM..", "..SP....", "..RQ...."}));
    ExampleRunner.eq(64, "YES", new AlphabetPath().doesItExist(new String[]{".....ST.Z", "GFEDCRUVY", "H..ABQPWX", "IJKLMNO.."}));
    ExampleRunner.eq(65, "YES", new AlphabetPath().doesItExist(new String[]{"..........XWV", "EFGHIJ...ZY.U", "DC...KLOPQRST", ".B....MN.....", ".A..........."}));
    ExampleRunner.eq(66, "YES", new AlphabetPath().doesItExist(new String[]{".Z.......", ".Y.......", "WX.......", "V........", "UT.......", ".S.......", ".RQ.....A", "..PONGF.B", "...LMHEDC", "...KJI..."}));
    ExampleRunner.eq(67, "YES", new AlphabetPath().doesItExist(new String[]{"..DC.", "GFEBA", "HIJK.", "...L.", "...M.", "...N.", "...O.", "UTSP.", "VWRQ.", ".X...", ".YZ.."}));
    ExampleRunner.eq(68, "YES", new AlphabetPath().doesItExist(new String[]{"DC.......", "EB.......", "FA.....YZ", "G.....WX.", "HI...UV..", ".JQRST...", ".KPO.....", ".LMN....."}));
    ExampleRunner.eq(69, "YES", new AlphabetPath().doesItExist(new String[]{"....ABCFG.", "......DEHI", "UTSRQPMLKJ", "VYZ..ON...", "WX........"}));
    ExampleRunner.eq(70, "YES", new AlphabetPath().doesItExist(new String[]{".......PQ...", ".......ORSTU", ".......N..WV", ".....KLM.YX.", ".....J...Z..", ".....I......", "ABCD.H......", "...EFG......"}));
    ExampleRunner.eq(71, "YES", new AlphabetPath().doesItExist(new String[]{"ZY.......", ".XUT.....", ".WVS.....", "..QR.....", "..PO.....", "...NML...", "....JK...", "....IH...", ".....GF..", "......E..", "......DC.", ".......BA"}));
    ExampleRunner.eq(72, "YES", new AlphabetPath().doesItExist(new String[]{"ZYXW......", "...V......", "...UT.....", "...RS.....", "...QP.....", "....ONML..", ".....IJK.A", ".....HEDCB", ".....GF..."}));
    ExampleRunner.eq(73, "YES", new AlphabetPath().doesItExist(new String[]{"..YZ..", ".WX...", ".VSR..", ".UTQPO", "CBALMN", "DGHK..", "EFIJ.."}));
    ExampleRunner.eq(74, "YES", new AlphabetPath().doesItExist(new String[]{"........Z", "........Y", "........X", "MN..STUVW", "LOPQR....", "KJ.BA....", "HIDC.....", "GFE......"}));
    ExampleRunner.eq(75, "YES", new AlphabetPath().doesItExist(new String[]{".YZ...", "WX....", "VU....", ".TS...", "..R...", "..QPO.", "..LMN.", "..KBC.", "..JADE", "..IHGF"}));
    ExampleRunner.eq(76, "YES", new AlphabetPath().doesItExist(new String[]{"Z............", "YX...........", ".WTS.........", ".VURQ.KJ.....", "....P.LI.....", "....ONMHGF...", ".........E...", ".........DCBA"}));
    ExampleRunner.eq(77, "YES", new AlphabetPath().doesItExist(new String[]{"......KJIH", "...ONML.FG", "..QP....ED", "..RS...ABC", "...T......", "ZWVU......", "YX........"}));
    ExampleRunner.eq(78, "YES", new AlphabetPath().doesItExist(new String[]{"...........A.", "...........BC", ".......KJIFED", ".....POL.HG..", ".....QNM.....", "..UTSR.......", "ZYV..........", ".XW.........."}));
    ExampleRunner.eq(79, "YES", new AlphabetPath().doesItExist(new String[]{".......CB", ".......DA", ".......E.", "...LK..F.", "..NMJIHG.", ".PO......", ".QR......", "..S......", "VUT......", "WX.......", ".Y.......", ".Z......."}));
    ExampleRunner.eq(80, "YES", new AlphabetPath().doesItExist(new String[]{"RQ......", "SP......", "TO......", "UNML....", "VWXKJ...", ".ZY.IH..", ".....GBA", ".....FC.", ".....ED."}));
    ExampleRunner.eq(81, "YES", new AlphabetPath().doesItExist(new String[]{"Z......", "YXW....", "..V....", "STU....", "R......", "QPMLK..", ".ONIJ..", "...H...", "...G...", "...F...", "...E...", "...DCBA"}));
    ExampleRunner.eq(82, "NO", new AlphabetPath().doesItExist(new String[]{"......................", "...SRO................", ".VUTQP...ED...........", ".WX..N...FCB..........", ".ZY..M.IHG.A..........", ".....LKJ..............", "......................"}));
    ExampleRunner.eq(83, "NO", new AlphabetPath().doesItExist(new String[]{"...............", "...............", "...............", ".....Z.........", "..OPQY.........", "..NSRXW........", ".LMT.UV........", ".KDC...........", "IJEBA..........", "HGF............"}));
    ExampleRunner.eq(84, "NO", new AlphabetPath().doesItExist(new String[]{".......................", ".......................", ".......................", ".......................", ".......................", ".......................", ".......................", "..CBA..................", "..D....................", "..E....................", "..F....................", "..G....................", "..HI...................", "...JK..................", "...ML..................", "...N.UT................", "...OPVS................", "....QWR................", ".....X.................", ".....Y.................", ".....Z.................", ".......................", ".......................", ".......................", ".......................", ".......................", ".......................", ".......................", "......................."}));
    ExampleRunner.eq(85, "NO", new AlphabetPath().doesItExist(new String[]{".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", ".........", "...KLM.YZ", "...JINWX.", "...GHOVU.", "..EF.PQT.", "..D...RS.", "..C......", "A.B......", ".........", ".........", "........."}));
    ExampleRunner.eq(86, "NO", new AlphabetPath().doesItExist(new String[]{"..............", "........Z.....", "........YX....", ".........W....", "......STUV....", "......R..ED...", "......QPGFC...", ".....MNOH.A...", ".....LKJI.B...", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", "..............", ".............."}));
    ExampleRunner.eq(87, "NO", new AlphabetPath().doesItExist(new String[]{"................", "................", "................", "................", "................", "................", "................", "................", "................", "................", "....JIHG........", "....KL.FE.......", "..PONM..DCB.....", "..Q.......A.....", "YXRS............", "Z.UT............", ".WV.............", "................", "................", "................", "................", "................", "................", "................", "................", "................", "................", "................", "................", "................", "................", "................"}));
    ExampleRunner.eq(88, "NO", new AlphabetPath().doesItExist(new String[]{"......................................", "......................................", "......................................", "......................................", "......................................", "..........ZY..........................", "...........X..SR......................", "...........WVUTQ......................", "...............P......................", "...............OKL....................", "...............NJM....................", "................I.....................", "................HG....................", "................AF....................", "................BE....................", "................CD....................", "......................................"}));
    ExampleRunner.eq(89, "NO", new AlphabetPath().doesItExist(new String[]{".....................................", ".....................................", ".....................................", "..........T.MLIHG....................", ".........VU.NKJ.F....................", ".........WSRO...EBA..................", ".........X.QP...DC...................", ".........Y...........................", ".........Z...........................", ".....................................", ".....................................", ".....................................", ".....................................", ".....................................", ".....................................", ".....................................", ".....................................", ".....................................", "....................................."}));
    ExampleRunner.eq(90, "NO", new AlphabetPath().doesItExist(new String[]{".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".................KL.PTUVW..............", ".................JMNOSZYX..............", ".................IHGQR.................", "...................FE..................", "....................D..................", "...................BC..................", "...................A...................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", "......................................."}));
    ExampleRunner.eq(91, "NO", new AlphabetPath().doesItExist(new String[]{"......PO..JI............", "....SRQNMLKH............", "....TU.....GFED.........", "...WXV........CBA.......", "...ZY...................", "........................"}));
    ExampleRunner.eq(92, "NO", new AlphabetPath().doesItExist(new String[]{"..................................................", "..................................................", "..................................................", "..................................................", "..........................YZ......................", "..........................X.......................", "..........................WVUT...KJI..............", ".............................SR.ML.H..............", "..............................Q.N.FG..............", "..............................P.O.E...............", "..................................D...............", "..................................CB..............", "...................................A..............", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", ".................................................."}));
    ExampleRunner.eq(93, "NO", new AlphabetPath().doesItExist(new String[]{"......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "......................", "..............YZ......", "..............X.......", "......................", "..............W.......", ".............UV.......", ".............TSRQPML..", ".................ONK..", "...................J..", "..................HI..", "..................GF..", "...................E..", "...................D..", "..................BC..", "..................A..."}));
    ExampleRunner.eq(94, "NO", new AlphabetPath().doesItExist(new String[]{"......................", "......................", "......................", ".............XW.......", "............ZYVUTSR...", "..................Q...", "..................P...", "..................O...", "............AB....N...", "...........EDC..KLM...", "...........FGHI.J.....", "......................", "......................"}));
    ExampleRunner.eq(95, "NO", new AlphabetPath().doesItExist(new String[]{"............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "........................................RQ..", "........................................SPO.", ".......................................UT.NM", "......................................ZV...L", "......................................Y...JK", "......................................XW.HI.", "........................................FG..", ".......................................DE...", ".......................................CB...", "........................................A..."}));
    ExampleRunner.eq(96, "NO", new AlphabetPath().doesItExist(new String[]{".XYZ.................................", ".W...................................", ".VUT.........ABC.....................", "...SRNMLKJIHGFED.....................", "....QOP..............................", "....................................."}));
    ExampleRunner.eq(97, "NO", new AlphabetPath().doesItExist(new String[]{".............", ".............", ".............", ".............", ".............", ".DCBA........", ".E...........", ".FG..........", "JIH..........", "KPOQ.........", "LMNRSTUV.....", ".......WX....", "........YZ...", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", "............."}));
    ExampleRunner.eq(98, "NO", new AlphabetPath().doesItExist(new String[]{"..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..............XYZ.........", "..............W...........", "...........IJ.VUT.........", "...........HKLMNS.........", "...........GFEDOR.........", "..............CPQ.........", "..............B.A.........", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", "..........................", ".........................."}));
    ExampleRunner.eq(99, "NO", new AlphabetPath().doesItExist(new String[]{".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", "..XYZ..", "..WVU..", "....T..", "....SR.", "..AB.Q.", "...CDP.", "..GFEON", "..HIJ.M", "....K.L", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", ".......", "......."}));
    ExampleRunner.eq(100, "NO", new AlphabetPath().doesItExist(new String[]{"...........AB.OP....................", "...........DCENQRST.................", ".............FM...U.................", ".............GLK..V.................", ".............HIJ..WX................", "...................Y................", "...................Z................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "....................................", "...................................."}));
    ExampleRunner.eq(101, "NO", new AlphabetPath().doesItExist(new String[]{"...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...........................", "...............MN..........", "...............LOPQRST.....", "...............K.....U.....", "....................WV.....", "............CBAJI.ZYX......", "............DEFGH..........", "...........................", "...........................", "...........................", "...........................", "...........................", "..........................."}));
    ExampleRunner.eq(102, "NO", new AlphabetPath().doesItExist(new String[]{".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", ".......................................", "....................B..................", "....................A..................", "....................CD...RS............", ".....................EF..QTUVW.........", "......................GHIPON.X.........", "........................JKLM.Y.........", ".............................Z........."}));
    ExampleRunner.eq(103, "NO", new AlphabetPath().doesItExist(new String[]{"..................AB.....", "..................DC.....", "..................EFG....", "....................H....", "..................JKI....", "..................ML.....", ".................ON......", ".................PQRS....", "..................ZYT....", "...................XU....", "...................WV....", ".........................", ".........................", "........................."}));
    ExampleRunner.eq(104, "NO", new AlphabetPath().doesItExist(new String[]{"............................", "............................", "............................", "YXWT.S......................", "Z.VU.R.LKJ..................", ".....QPMHI..................", "......ONG...................", ".......AF...................", ".......BE...................", ".......CD...................", "............................"}));
    ExampleRunner.eq(105, "NO", new AlphabetPath().doesItExist(new String[]{"........................................", "........................................", "........................................", ".......................KJ...............", ".......................LIFED............", ".......................MHG.CBA..........", ".......................NOPTS............", ".........................QUR............", "..........................VW............", "...........................X............", "...........................Y............", "...........................Z............", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................"}));
    ExampleRunner.eq(106, "NO", new AlphabetPath().doesItExist(new String[]{".....................................", ".....................................", ".....................................", ".....................................", ".....................................", ".....................................", ".....................................", "..........AB.........................", "..........DC.........................", "........GFE..........................", "..........KL..WXYZ...................", "........HIJMN.V......................", "...........POTU......................", "...........QRS.......................", ".....................................", ".....................................", ".....................................", "....................................."}));
    ExampleRunner.eq(107, "NO", new AlphabetPath().doesItExist(new String[]{"................", "................", "................", "................", "................", "................", "................", "................", "................", "................", ".BC.............", ".AD.............", "..E.............", "..F.............", "..GHKLM.........", "...IJ.NRS.......", "......PQTUV.....", "......O...WXYZ.."}));
    ExampleRunner.eq(108, "NO", new AlphabetPath().doesItExist(new String[]{".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", "..............................Z..............", "............................WXY..............", "............................VU...............", "............................ST...............", "........................I.JKR................", "........................H.MLQ................", "........................GFNOP................", ".........................EDCBA...............", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", ".............................................", "............................................."}));
    ExampleRunner.eq(109, "NO", new AlphabetPath().doesItExist(new String[]{"................", ".....RQ.........", ".....SPONM......", ".....T...LK.....", ".....UV...J.....", ".....XW...IH....", ".....Y.....GF...", ".....Z.......A..", "............EB..", "............DC..", "................", "................", "................", "................", "................"}));
    ExampleRunner.eq(110, "NO", new AlphabetPath().doesItExist(new String[]{".........................................", ".........................................", ".........................................", "...................................QR....", "...................................PS....", "..................................NOTUYX.", "................................KLM..VZW.", "...............................IJA.......", "...............................H.B.......", "...............................GFC.......", "................................ED.......", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", "........................................."}));
    ExampleRunner.eq(111, "NO", new AlphabetPath().doesItExist(new String[]{"........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "..................................XYZ...", "..................................WV....", "..................................TU....", "..................................SR....", "...............................LKM.Q....", "...............................IJNOP....", "...............................HGFEDC...", "....................................BA..", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................"}));
    ExampleRunner.eq(112, "NO", new AlphabetPath().doesItExist(new String[]{".....................", ".....................", ".......TUS...........", "........VRQBA........", "........WOPCD........", ".......YXNKJE........", ".......Z.MLIF........", "...........HG........", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", ".....................", "....................."}));
    ExampleRunner.eq(113, "NO", new AlphabetPath().doesItExist(new String[]{"...................", "......TS...........", ".....VURQ..........", "...ZYWX.PO.........", "........MN.........", "........LK.........", ".........J.........", "........HI.........", "........G..........", ".......EF..........", ".......D...........", ".......CB..........", "........A..........", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "..................."}));
    ExampleRunner.eq(114, "NO", new AlphabetPath().doesItExist(new String[]{"..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "..........................................", "....................UTS...................", "....................VQR...EF..............", "...................XWP.ABCDG..............", "...................YZOLK.JIH..............", ".....................NM...................", "..........................................", ".........................................."}));
    ExampleRunner.eq(115, "NO", new AlphabetPath().doesItExist(new String[]{".....YZ................", ".....XW................", "......VU...............", ".......T...............", ".....QRS...............", "LMNO.P.................", "KJI....................", ".GH....................", ".F.....................", ".E.....................", "CD.....................", "B......................", "A......................", ".......................", ".......................", ".......................", ".......................", ".......................", ".......................", ".......................", ".......................", ".......................", "......................."}));
    ExampleRunner.eq(116, "NO", new AlphabetPath().doesItExist(new String[]{".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", "......CBA....", "......DE.....", "......GF.....", "......H......", "......I.JKLMN", ".........TSPO", ".........URQ.", ".........VW..", "........ZYX..", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", "............."}));
    ExampleRunner.eq(117, "NO", new AlphabetPath().doesItExist(new String[]{"..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "..................................................", "............................LKJ.AB................", ".........................ZONM.I.HC................", ".........................YP.....GD................", ".........................XQR....FE................", ".........................WTS......................", ".........................VU.......................", "..................................................", "..................................................", ".................................................."}));
    ExampleRunner.eq(118, "NO", new AlphabetPath().doesItExist(new String[]{"................................", "................................", "................................", "................................", "................................", "................................", "....EFGJKNOQP...................", "....DCHILMSR....................", ".....BA..UTYZ...................", ".........VWX....................", "................................"}));
    ExampleRunner.eq(119, "NO", new AlphabetPath().doesItExist(new String[]{"...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "..........ZY...............................", "..........WX...............................", "..........VU...............................", ".........RST...............................", ".........Q.................................", ".........P.................................", ".........NMLK..............................", ".........O..JIFE...........................", ".............HGD...........................", "...............C...........................", "...............BA..........................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "...........................................", "..........................................."}));
    ExampleRunner.eq(120, "NO", new AlphabetPath().doesItExist(new String[]{"................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "...................KJ...........", "..................MLIH..........", "..................NO............", "...................PQGF.........", "....................RSE.........", ".....................TDCBA......", ".....................UV.........", "......................WX........", ".......................Y........", ".......................Z........", "................................", "................................", "................................", "................................"}));
    ExampleRunner.eq(121, "NO", new AlphabetPath().doesItExist(new String[]{"..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "...............A..", "...............B..", "...............C..", "..............ED..", "..............F...", "............HIG...", ".............JK...", "..............LM..", "...........TSRQN..", "...........UV.PO..", ".........ZYXW.....", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", "..................", ".................."}));
    ExampleRunner.eq(122, "NO", new AlphabetPath().doesItExist(new String[]{"...BACDEFGHIJ.......", ".....ZWV.RQ.KL......", ".....YXUTSPONM......", "...................."}));
    ExampleRunner.eq(123, "NO", new AlphabetPath().doesItExist(new String[]{"...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "........CDE........", "........BGF........", "........AH.........", ".........IJ........", "........MLK........", ".......ON..........", "......QP...........", ".....SR............", ".....TU............", "......VWX.Y........", "..........Z........", "...................", "...................", "...................", "...................", "...................", "...................", "..................."}));
    ExampleRunner.eq(124, "NO", new AlphabetPath().doesItExist(new String[]{"...................................", "...................................", "...................................", "...................................", "............................A......", "............................B......", "....................XWV.....C......", "....................YZUTSR.........", ".........................Q.ED......", ".........................P.FG......", ".........................O..H......", ".........................NMLI......", "...........................KJ......", "...................................", "...................................", "..................................."}));
    ExampleRunner.eq(125, "NO", new AlphabetPath().doesItExist(new String[]{".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".........................................", ".............................YZ..........", ".........................RST.X...........", ".........................Q.UVW...........", "........................OP...............", ".......................MN................", ".......................L.................", "......................JK.................", ".........................................", "....................GHI..................", "...................AF....................", "...................BE....................", "...................CD....................", "........................................."}));
    ExampleRunner.eq(126, "NO", new AlphabetPath().doesItExist(new String[]{"................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", "................................", ".................TU.............", ".................SVW............", ".................RQXYZ..........", "................................", "..................POBC..........", "...................NAD..........", "...................M.E..........", "...................L.FG.........", "...................KJIH.........", "................................"}));
    ExampleRunner.eq(127, "NO", new AlphabetPath().doesItExist(new String[]{".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", "...AB........", "....CD.......", "....FE.Z.....", "....GH.......", "...KJIXY.....", "..MLQRW......", "..NOPSV......", ".....TU......", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", ".............", "............."}));
    ExampleRunner.eq(128, "NO", new AlphabetPath().doesItExist(new String[]{"...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...Z...............", "...................", "...Y...............", "...XWVUTS.....AB...", "........RQ.....CD..", "........OP......E..", "........NMLKJIHGF..", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "...................", "..................."}));
    ExampleRunner.eq(129, "NO", new AlphabetPath().doesItExist(new String[]{"...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................A.BC............", ".....................ED............", ".....................FIJ...........", ".....................GHK...........", "......................ML...........", "......................NOP..........", ".......................RQ..........", ".......................S...........", "......................UT...........", "......................VYZ..........", "......................WX...........", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "...................................", "..................................."}));
    ExampleRunner.eq(130, "NO", new AlphabetPath().doesItExist(new String[]{".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", ".....................IHGF", ".....................JK.E", ".................Z....L.D", ".................Y....M.C", ".................XWQPON.B", "..................V.....A", "..................UR.....", "..................TS.....", ".........................", ".........................", ".........................", ".........................", ".........................", ".........................", "........................."}));
    ExampleRunner.eq(131, "NO", new AlphabetPath().doesItExist(new String[]{"..........", "..........", "..........", "....ZHG...", "...XYIF...", "...W.JEDA.", "...VLK.CB.", "...UM.....", "...TNPO...", "...SRQ....", "..........", "..........", "..........", ".........."}));
    ExampleRunner.eq(132, "NO", new AlphabetPath().doesItExist(new String[]{".........Z", "......WX.Y", ".....UV...", "...PQT....", "..NORS....", "KLMFE.....", "JIHGDC....", ".....BA..."}));
    ExampleRunner.eq(133, "NO", new AlphabetPath().doesItExist(new String[]{"CDE......", "B.FGHIJK.", "A.....ML.", "......N..", "......O..", "....UVWX.", "....TQPYZ", "....SR..."}));
    ExampleRunner.eq(134, "NO", new AlphabetPath().doesItExist(new String[]{".ON.....D", ".PMLK.GFE", ".Q..JIH.C", ".RST...AB", "XWVU.....", "Y........", "Z........"}));
    ExampleRunner.eq(135, "NO", new AlphabetPath().doesItExist(new String[]{"........EDC.", "UTSR..JIF.BA", "VW....KHG...", ".X.QP.L.....", "ZY..ONM....."}));
    ExampleRunner.eq(136, "NO", new AlphabetPath().doesItExist(new String[]{".KJI...", "ML.HGF.", "NOP..ED", ".RQ..BC", ".S...A.", "VTU....", "WX.....", ".YZ...."}));
    ExampleRunner.eq(137, "NO", new AlphabetPath().doesItExist(new String[]{"YX.....", "ZW.....", ".VUT...", "..RS...", "..Q....", "..PNO..", "...M...", "..KLGF.", "..JIHE.", ".....DA", ".....CB"}));
    ExampleRunner.eq(138, "NO", new AlphabetPath().doesItExist(new String[]{"..WX...", "TUVYZ..", "S......", ".......", "RQPON..", ".JKLM..", ".IH....", "..GFCBA", "...ED.."}));
    ExampleRunner.eq(139, "NO", new AlphabetPath().doesItExist(new String[]{".....PQ..", "...HIORS.", "...GJNKT.", "ADEF.MLUV", "BC....YXW", "......Z.."}));
    ExampleRunner.eq(140, "NO", new AlphabetPath().doesItExist(new String[]{"......AB", ".......C", ".....FED", ".....G..", "...JIH..", "..LK....", "SRM.....", ".QN.....", "TPO.....", "U.......", "VWX.....", "..YZ...."}));
    ExampleRunner.eq(141, "NO", new AlphabetPath().doesItExist(new String[]{"JK.......", "ILM.NOPYZ", "HGFE.RQX.", "...D.STW.", "...C..UV.", "...B.....", "...A....."}));
    ExampleRunner.eq(142, "NO", new AlphabetPath().doesItExist(new String[]{".BDC.YX.", ".AE..ZW.", ".GF...VU", "IH...RST", "JKLMPQ..", "...NO..."}));
    ExampleRunner.eq(143, "NO", new AlphabetPath().doesItExist(new String[]{"ZY.......", ".X.RQJKL.", ".WVSPONM.", "..UT.IHG.", "......EF.", "......DCB", "........A"}));
    ExampleRunner.eq(144, "NO", new AlphabetPath().doesItExist(new String[]{".UVW......", "STYX......", "RQZ.......", ".PO..IHG..", "..N....FAB", "..MLKJ.EDC"}));
    ExampleRunner.eq(145, "NO", new AlphabetPath().doesItExist(new String[]{"...........Z", "...........Y", "...ALM...VWX", "EDCBKN...U..", "FGHIJO..ST..", ".....PQ.R..."}));
    ExampleRunner.eq(146, "NO", new AlphabetPath().doesItExist(new String[]{"L.KJ..", "MN.IH.", ".O..GF", ".PSTDE", ".QRUC.", "..WVBA", "..X...", "..Y...", "..Z..."}));
    ExampleRunner.eq(147, "NO", new AlphabetPath().doesItExist(new String[]{"......Z", "......Y", "ADEQR.X", "BCFPSTW", "..GOHUV", "...NIJ.", "...MLK."}));
    ExampleRunner.eq(148, "NO", new AlphabetPath().doesItExist(new String[]{"....A", "....B", "..EDC", "..F..", "..G..", ".IH..", "KJNO.", "L.MP.", "...QR", "..UTS", "..V..", ".XW..", ".YZ.."}));
    ExampleRunner.eq(149, "NO", new AlphabetPath().doesItExist(new String[]{"CDE.....", "BAF.....", "..G.....", ".IH.....", ".JKNOP..", "..LM..YZ", ".....QXW", ".....RSV", "......TU"}));
    ExampleRunner.eq(150, "NO", new AlphabetPath().doesItExist(new String[]{"QRS...", "POTUYZ", "MNWVX.", "LKHGF.", ".JI.E.", "....DA", "....CB"}));
    ExampleRunner.eq(151, "NO", new AlphabetPath().doesItExist(new String[]{"..UT.....", "Z.VS.....", "YXWR.....", "..PQ.....", "..ON.....", "...MLKJ.I", ".......GH", "......EFA", "......DCB"}));
    ExampleRunner.eq(152, "NO", new AlphabetPath().doesItExist(new String[]{"W.X........", ".ZY........", "VUT........", "...........", ".PS...DCB.A", ".QRHGFE....", ".O.I.......", ".NKJ.......", ".ML........"}));
    ExampleRunner.eq(153, "NO", new AlphabetPath().doesItExist(new String[]{"..IH...A", "..JG.C.B", "..KFED..", "XWVPUQ..", "YZLOTS..", "..MN.R.."}));
    ExampleRunner.eq(154, "NO", new AlphabetPath().doesItExist(new String[]{"Z......", ".......", "YXW....", "..V....", "..UR...", "..TS...", ".POQ...", ".......", "..N....", ".LM....", ".K.....", ".J.....", ".IDCB.A", ".HE....", ".GF...."}));
    ExampleRunner.eq(155, "NO", new AlphabetPath().doesItExist(new String[]{"...ABC...", ".....D...", ".....E...", "..I.HG...", "LKJ..F.ZY", "MPQ.R....", "NO......X", "....STUVW"}));
    ExampleRunner.eq(156, "NO", new AlphabetPath().doesItExist(new String[]{"....PQ...", "..MNOR...", "..L..S...", ".WKVUT...", "YXJ.I....", "....HG...", "Z....FE..", "......D..", ".........", "......C.B", "........A"}));
    ExampleRunner.eq(157, "NO", new AlphabetPath().doesItExist(new String[]{"A..........TUX.", "B....M.NO..SVW.", ".....L..PQ.R.YZ", "CD...K.........", ".E...J.........", ".F.GHI........."}));
    ExampleRunner.eq(158, "NO", new AlphabetPath().doesItExist(new String[]{"....ABC..", "......D..", "......E..", ".....GF..", "Z....HI..", "......J.K", "YX....MNL", ".WV....O.", "..UTS....", "....RQ.P."}));
    ExampleRunner.eq(159, "NO", new AlphabetPath().doesItExist(new String[]{"Z........CDE", "....PON.IHGF", "Y.S.R...JBA.", "XUT.Q.MLK...", "WV.........."}));
    ExampleRunner.eq(160, "NO", new AlphabetPath().doesItExist(new String[]{"...........ZY", ".............", "...........WX", ".........TUV.", ".........S...", ".CAB...OPQ...", ".D...M.N.R...", "FE...L.......", "GHIJ.K......."}));
    ExampleRunner.eq(161, "NO", new AlphabetPath().doesItExist(new String[]{".....A", "..IGHB", "..JEDC", "..KF..", "......", "..LM..", "..RQP.", "Z.SNO.", "YUT...", "X.....", "WV...."}));
    ExampleRunner.eq(162, "NO", new AlphabetPath().doesItExist(new String[]{"IJK...", "H.....", "GFLM..", ".EON..", "ADPQ.R", "BCUT.S", "..V...", "...Z..", "..W...", "..XY.."}));
    ExampleRunner.eq(163, "NO", new AlphabetPath().doesItExist(new String[]{".W.VUST......", "YX...RQLK....", "Z.....PMJI...", "......ONGHFAE", "..........CBD"}));
    ExampleRunner.eq(164, "NO", new AlphabetPath().doesItExist(new String[]{"BDC...", "AE....", "GF...P", "HIJKNO", ".Z.LMQ", ".Y.T.S", "...U.R", ".XWV.."}));
    ExampleRunner.eq(165, "NO", new AlphabetPath().doesItExist(new String[]{".....S.......", "....PTU.V.WX.", "....QR.....YZ", "....ON.......", ".DE.LM.......", ".CFGK........", "ABIHJ........"}));
    ExampleRunner.eq(166, "NO", new AlphabetPath().doesItExist(new String[]{"....PQ.R....", ".F..ON.ST.XY", "BGHKLM....WZ", "AEIJ....U.V.", "CD.........."}));
    ExampleRunner.eq(167, "NO", new AlphabetPath().doesItExist(new String[]{"...IH.BA", "NK.JGFC.", "ML...ED.", "OQP.....", ".RTS....", "..UV....", "...ZY...", "...WX..."}));
    ExampleRunner.eq(168, "NO", new AlphabetPath().doesItExist(new String[]{"XW.V........", "...UTS......", "YZ.........A", "....QR..DC.B", "....PONME...", ".....JKLF...", ".....I.HG..."}));
    ExampleRunner.eq(169, "NO", new AlphabetPath().doesItExist(new String[]{"IJ.K.....", "HG.......", ".FEL.....", ".CDM.....", ".BPO.....", ".AQN.....", "..RS.....", "...T.....", "...UV....", ".........", "....WX.YZ"}));
    ExampleRunner.eq(170, "NO", new AlphabetPath().doesItExist(new String[]{"..MN...", "BALO...", "C..P...", "DJKQ...", "EI.R...", "FHGST..", "......Z", "....U..", ".....XY", "....VW."}));
    ExampleRunner.eq(171, "NO", new AlphabetPath().doesItExist(new String[]{"........BA", "...WZ...C.", "...XY...D.", ".U.V...FE.", ".T.S...G..", "POQR......", ".NMLKJIH.."}));
    ExampleRunner.eq(172, "NO", new AlphabetPath().doesItExist(new String[]{"ABC.......", "...DEFGHIJ", "TSRQPONMLK", "UVWXYZ...."}));
    ExampleRunner.eq(173, "NO", new AlphabetPath().doesItExist(new String[]{"ACBDEFGHIJKLMNOPQRSTUVWXYZ"}));
    ExampleRunner.eq(174, "YES", new AlphabetPath().doesItExist(new String[]{"..............", "..............", "..............", "...DEFGHIJK...", "...C......L...", "...B......M...", "...A......N...", "..........O...", "..ZY..TSRQP...", "...XWVU.......", ".............."}));
    ExampleRunner.eq(175, "YES", new AlphabetPath().doesItExist(new String[]{"ABCDEFGHIJKLMNOPQRSTUVWXYZ"}));
    ExampleRunner.eq(176, "NO", new AlphabetPath().doesItExist(new String[]{"A.BCDEFGHIJKLMNOPQRSTUVWXYZ"}));
    ExampleRunner.eq(177, "NO", new AlphabetPath().doesItExist(new String[]{"..............", "..............", "..............", "...DEFGHIJK...", "...C......L...", "...B......M...", "...A......N...", "..........O...", "...Y..TSRQP...", "...XWVU.......", ".............Z"}));
    ExampleRunner.eq(178, "NO", new AlphabetPath().doesItExist(new String[]{"AZBCDEFGHIJKLMNOPQRSTUVWXY"}));
    ExampleRunner.eq(179, "YES", new AlphabetPath().doesItExist(new String[]{"............................", "...A........................", "...BCDEFGHIJKLMNOPQRSTUVWXYZ"}));
  }
}
